% Answers for galley proofs:

\ansno6.1:
 No, the second token represents $1\over65536$. \ (A token has
the same meaning as~`|0|' ↑↑{zero} if and only if its decimal value
is strictly less than $2↑{-17}=.00000\,76293\,94531\,25$.) \ (b)~Yes; both
tokens represent $1\over65536$, because 1~is the nearest integer to both
$.00001\times65536=.65536$ and $0.00002\times65536=1.31072$. \ (c)~No,
|0.00003| represents $2\over65536$. \ (d)~Yes, they both mean ``↑{enormous
number} that needs to be reduced''; \MF\ complains in both
cases and substitutes the largest legal numeric token.  \ (When
4095.999999 is rounded to the nearest multiple of $1\over65536$, the
result is 4096, which is too big.)

\ansno6.2:
 `|xx|', `|3.1|' (a numeric token), `|.6|' (another numeric token),
`|..|', `|[[|', `|a|', `|+-|', `|bc_d|', `|e|', `|]|', `|]|', `|"a %"|'
(a string token), `|<|\||>|', `|(|' (see rule~5), `|(|', `|$|', `|1|'
(a numeric token), `|5|' (likewise numeric), `|"+-"|' (a string token),
and `|""|' (a string token that denotes an empty sequence of characters).
All of these tokens are symbolic unless otherwise mentioned. \ (Notice that
four of the spaces and two of the periods were deleted by rule~1.
One way to verify that \MF\ finds precisely these tokens is to prepare a
test file that says `|isolated| |expression;|' on its first line and that
contains the stated text on its second line. Then respond to \MF's
error message by repeatedly typing `|1|', so that one token is deleted
at a time.)

\ansno6.3:
 The statement is basically true but potentially misleading. You can
insert any number of spaces {\sl between\/} tokens without changing the
meaning of a program, but you cannot insert a space in the {\sl middle\/}
of any token without changing something. You can delete spaces between
tokens {\sl unless\/} that would ``glue'' two adjacent tokens together.

\ansno6.4:
 False. It may seem that this new sort of numeric token would be
recognized only in cases where the period is not followed by a digit,
hence the period would be dropped anyway by rule~1. However, the new rule
would have disastrous consequences in a line like `|draw| |z1..z2|'!

\ansno7.1:
 You can put a space between the subscripts, as in `|a1|~|5|'. \
(We'll see later that a ↑{backslash} acts as a null symbol,
hence `|a1\5|' is another solution.)

\ansno7.2:
 No; |a[-1]| can't be accessed without using |[| and |]|. The
only other form of \<subscript> is \<numeric token>, which can't be
negative. \ (Well, strictly speaking, you could say `|let|~|?=[;|
|let|~|??=]|' and then refer to `|a?-1??|'; but that's cheating.
Furthermore it turns out that negative numeric tokens can arise in certain cases
when macro parameters are being massaged; but that's too tricky.)

\ansno7.3:
 Assuming that `|+|' was still a spark when he said `|let|~|plus=+|',
he can't refer to the variable `|a.plus1|' unless he changes the meaning of
|plus| again to make it a~tag. \ (We will eventually learn a way to do this
without permanently clobbering |plus|, as follows: `↑|begingroup| ↑|save|
|plus;| |a.plus1| ↑|endgroup|'.)

\ansno7.4:
 True. \ (But a \<suffix> is not always a \<variable>.)

\ansno7.5:
 Yes, because it removes any existing value that $x$ may have
had, of whatever type; otherwise you couldn't safely use $x$ in a
numeric equation. It's wise to declare numeric variables when you're
not sure about their former status, and when you're sure that you don't
care what their previous value was. \ (Incidentally, `|numeric|~|x|'
doesn't affect other variables like `|x2|' or `|x.x|' that might be present.)

\ansno7.6:
 (a)~The `|42|' is illegal because subscripts must be collective.
\ (b)~The `|24|' is illegal because a \<declared variable> must start with
a \<symbolic token>, not a numeric token. \ (c)~There's nothing wrong with
the consecutive commas; the second comma begins a \<declared variable>, so
it loses its former meaning and becomes a tag. Thus \MF\ tries to declare
the variable `|,t,path|'. However, `|path|' cannot appear in a suffix,
since it's a spark. \ (Yes, this is admittedly tricky. Computers follow rules.)